International markets comprise an ever-increasing percentage of revenue for software developers. In an effort to create multiple language-versions of a base software product to satisfy the demands of the international marketplace, developers typically rely on a process known as localization.
Localization generally refers to a process of altering a software application by translating strings, dialogs, messages, and the like, as well as other components of the software application's user-interface, and/or manipulating functions of the application to accommodate a country's languages, conventions, and cultures (collectively, these locale-specific features will be referred to herein as “UI code”). In effect, localization creates a software product with a locale-specific front end or user-interface, while the middle of the software application, which includes the programming code that defines the functionality of the application, remains unchanged.
Localization may be effectuated by maintaining UI code in repositories or files accessible by, but separate from, the functional code of the software application. Various specific language-versions of the software application may then be built, compiling and linking the functional code with the locale-specific translations of the UI code, which would otherwise be displayed on the user-interface in the language, or with the attributes, of the base version of the application (e.g., English/US attributes). For example, one may think of the UI code as a table comprising a number of rows each containing a specific word or UI code attribute, and a number of columns each representing a different language or locale. If the first column contains rows of UI code specific to the base-language version of the software application (e.g., English), other columns may contain Japanese-language specific UI code, or Swedish-language specific UI code corresponding to the base-language word or attribute contained in a given row. At run-time, the functional code accesses the locale-specific UI code as it is needed, to enable a locale-specific user interaction with the software application.
In order for localization to be effective, the software product must be substantially free of internationalization defects (“bugs”), such as hard-coded strings, hard-coded formats, hard-coded references to translations, matching translation requirements, or the like, which will prevent the software application from providing a locale-specific user-interface during run-time. For example, a typical internationalization bug might be a hard-coded string, a data structure that depends on a value embedded in the program code, rather than on a value (such as those words or attributes contained in the language-specific columns of the table described above) that may be input or changed (e.g., via a translation process). Because the value associated with the string is embedded in the program code, it cannot be altered without physically changing the code, and consequently, the generated user-interface cannot be made locale-specific with reference to the locale-specific translations.
Software developers generally strive to identify and fix internationalization bugs during the development of the localized versions of the application in order to reduce or eliminate the necessity to fix problems discovered by consumers of the software product in the future. One way to identify internationalization bugs in the software application is to build and test a language-specific version of the application with translated UI code, and identify problems with the locale-specific user-interface. However, because the locale-specific translation process is typically time-intensive, waiting for actual translations often results in increased costs and extended delays, as developers seek to implement fixes for bugs discovered after the actual translations have been delivered. As a result, developers often rely on a pseudo-translation of the UI code in order to test their developing application, and to facilitate delivery of a final product in a more timely manner. Testing a software application via a pseudo-translation is commonly referred to as pseudo localization.
Pseudo localization refers to a process of simulating localization by altering translatable base-language UI code, by for example, adding prefix characters or the like to all translatable strings in a software product. One may then identify internationalization bugs from those strings that do not appear as pseudo-translated strings in the user-interface of the pseudo-language build of the application. Typical pseudo localization procedures are manually implemented for specific features of an application and generally require a relatively large amount of time and human effort to accomplish the desired objectives.